DirectX Raytracing (DXR) now supports Opacity Micromaps (OMMs), enabling hardware to handle alpha tested geometry more efficiently than relying only on costly AnyHit shader invocations.

At GDC 2025 DXR 1.2 was announced including OMMs, and you can see it discussed in this: GDC DirectX State Of The Union YouTube Recording. In the video, Remedy showed the performance wins they achieve using a synergistic combination of OMMs and Shader Execution Reordering in Alan Wake 2.

Out of the gate all NVIDIA raytracing capable hardware supports OMMs (currently developer preview drivers).  Over time additional hardware vendor support for OMMs will appear.

The rest of this blog summarizes the feature, how to get bits, and highlights some sample code to help get started.

Parent blog for all other features in this release.

Motivation

Very high quality, high-definition opacity (alpha) content is usually very coherent, or locally similar.

Typically, there are larger regions that are completely transparent or opaque within meshes that do not necessarily coincide with triangle boundaries.

Furthermore, in DXR Tier 1.1, the opaque/non-opaque properties of triangles are geometry-wide, but it might be impractical to split up meshes into several geometry pieces. As a consequence, any-hit shaders are often invoked for ray-triangle hits that could be trivially categorized as a miss or a hit.

Overview

To reduce the overhead of redundant and potentially expensive any-hit shaders, Opacity Micromaps (OMMs) are added to triangle primitives as a part of DXR Tier 1.2 (D3D12_RAYTRACING_TIER_1_2).

The Opacity Micromap is defined on a sub-triangle detail level, encoded in a uniformly subdivided mesh of 4^N micro-triangles, laid out on a 2N × 2N barycentric grid.

Here is a diagram of the first few levels of the subdivision scheme:

Briefly, OMMs can be used to cull any-hit shading invocations in regions within a triangle known to be completely opaque or transparent. It is also possible to bypass any-hit shading completely, and use the mask as high frequency geometric detail on the triangle. Individual OMMs store (compact) information about how to modulate a base triangle to add the extra detail, much like traditional texture mapping.

Here is an example of OMM detail applied to a base triangle:

Opacity micromaps are bit masks of one or two bits per micro-triangle.

1-bit OMMs mark each corresponding micro-triangle as either opaque (D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE) or transparent (D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT) and never requires any-hit shader intervention during the tracing of a ray.

2-bit OMMs are used if there are portions of the opacity that need to be resolved in an any-hit shader. A third translucent or “unknown” micro-triangle state is used for this purpose. The 2-bit OMM encodes four states (instead of only three) which affords some flexibility of interpretation: in some ray-traced effects, exact resolution is not required. For example, soft shadows may be resolved using a lower resolution proxy.

To facilitate use of such proxies the four states of a 2-bit OMM are transparent, opaque, unknown transparent (D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT), and unknown opaque (D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE).

In one mode of interpretation, unknown transparent is associated with transparent, and unknown opaque with opaque, and in doing so interpreting it as a 1-bit map without unknown states. This is referred to as operating in 2-state mode.

In a second mode of interpretation of the four states, the any-hit shader is invoked when the micro-triangle that is struck is categorized as either of the unknowns. This is referred to as operating in 4-state mode.

OMMs can be constructed with either 2 or 4 states (D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE or D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE).

4-state OMMs can operate in a 2-state interpretation mode through ray and instance flags, RAY_FLAG_FORCE_OMM_2_STATE or D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE.

The OMM micro-triangle states are organized along a space-filling curve in barycentric space, depicted here:

Unlike triangles, the OMMs are not stored directly in the bottom-level acceleration structures (BLAS), but instead reside in separate resources. Individual OMMs may be referenced by triangles from within a BLAS. Because OMMs storage is separate from the BLASes, they can be reused across multiple BLASes in a scene.

Before OMMs can be used with raytracing, they must be processed by the driver. This is similar to how triangles and procedural primitives must be built into a BLAS before they can be used.

Collections of OMM inputs are used to construct OMM Arrays using the same API as for building acceleration structures: BuildRaytracingAccelerationStructure() on the command list. Here is an example of a collection of OMMs in an OMM Array:

Like acceleration structures, the OMM Arrays are opaque data structures, but the application is responsible for memory management. The amount of memory required for an OMM Array can be queried via the same method used for acceleration structures: GetRaytracingAccelerationStructurePrebuildInfo() device member function. Opaque OMM Array data must reside in resources that are permanently in the state D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, just like acceleration structures. It is fine to mix acceleration structures and OMM array data in the same allocations.

The application can reference specific entries within an array by their input-order index to link specific entries to specific triangles in a BLAS. To construct an OMM Array, the application provides an input buffer with micro-triangles in one of the supported encodings, which the driver assembles into a raytracing-compatible format.

The application can link an OMM Array per geometry, from which detailed opacity information is retrieved during ray traversal. This is illustrated in the diagram below. The OMM feature is accessible for BLAS builds through the use of a new geometry description, D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC, which contains additional inputs to the BuildRaytracingAccelerationStructure() function.

If an OMM Array is overwritten with new OMM data, any BLASes referencing it become stale and must be updated. It is also possible to assign a different OMM Array and OMM indices when updating a BLAS. The new AS build flag D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_LINKAGE_UPDATE lets the driver know that OMM contents may change with BLAS updates.

OMM Arrays can be copied around, serialized/deserialized etc. just like acceleration structures via the various modes of CopyRaytracingAccelerationStructure().

Specification (Docs)

For full documentation see the Opacity Micromaps section of the DXR spec.

This spec also has a section describing D3D12_RAYTRACING_TIER_1_2 including how OMM fits in.

The above overview is made from spec excerpts.

Authoring OMMs

NVIDIA have CPU and GPU based OMM bakers available in their OMM SDK.  These tools convert existing alpha tested/blended content into OMMs and can avoid the need to author OMMs directly.

Availability

The majority of the OMM feature is available via retail AgilitySDK 1.616.1 available here, paired with a driver that reports support for D3D12_RAYTRACING_TIER_1_2. A subset of the OMM feature (RayQuery combined with OMM) requires Shader Model 6.9 which is currently in preview, discussed in DXC Support below.

NVIDIA: OMM is already accelerated on all NVIDIA GeForce RTX™ GPUs, access the driver here (requires an NVIDIA Developer Program account).

AMD: AMD driver support for OMMs will be made available during Summer 2025

Intel: Intel is actively evaluating OMMs and looks forward to supporting the feature in the future.

WARP: The latest WARP software rasterizer preview also supports DXR 1.2 including OMM. 1.0.14.2 supports OMMs. 1.0.15-preview supports OMMs + SM6.9.

To check for OMM support, look for D3D12_RAYTRACING_TIER_1_2:

ThrowIfFailed(m_dxrDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, 
                                                  &featureSupportData, 
                                                  sizeof(featureSupportData)));
if (featureSupportData.RaytracingTier < D3D12_RAYTRACING_TIER_1_2)
{
    // OMM not supported
}

DXC Support

There is small part of OMMs that requires HLSL code changes. This is the use of OMMs with inline raytracing (RayQuery). For this, Shader Model 6.9 is needed for a new variant of the RayQuery object that enables template flags opting into OMMs.

Shader Model 6.9 is currently in preview, so to use OMMs with RayQuery currently requires:

• AgilitySDK 1.717.1-preview available here.
• Preview Shader Model 6.9 support in DXC available here.

To use the preview AgilitySDK with shader model 6.9, your machine needs to be in developer mode, and before calling D3D12CreateDevice() enable experimental shader modelslike this:

UUID Features[] = { D3D12ExperimentalShaderModels };
ThrowIfFailed(D3D12EnableExperimentalFeatures(_countof(Features), Features, nullptr, nullptr));

After creating a device, check for Shader Model 6.9 support:

D3D12_FEATURE_DATA_SHADER_MODEL SM;
SM.HighestShaderModel = D3D_SHADER_MODEL_6_9;
m_dxrDevice->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &SM, sizeof(SM));
ThrowIfFalse(SM.HighestShaderModel >= D3D_SHADER_MODEL_6_9,
    L"ERROR: Device doesn't support Shader Model 6.9.\n");

The other small part of the OMM feature that appears in HLSL code is the RAY_FLAG_FORCE_OMM_2_STATE ray flag that makes a 4-state OMM act as 2-state (unknown-opaque state becomes opaque, and unknown-transparent becomes transparent). This flag requires the latest DXC to be natively supported, but if you need to remain on an older version of DXC you can still use this flag by adding this to your shader code:

#define RAY_FLAG_FORCE_OMM_2_STATE 0x400

PIX

As usual, OMMs come with Day One PIX support. This includes support for visualizing OMMs inside PIX’s acceleration structure viewer. Please read the PIX blog post for more information.

Content from NVIDIA

OMM-Samples demonstrates how Opacity Micromaps can accelerate raytracing in scenes with complex alpha testing. It includes examples of GPU/CPU baking using the OMM baking library, and now also features support for DXR 1.2, expanding compatibility across an even broader range of hardware.

Microsoft OMM Sample

D3D12RaytracingOpacityMicromaps is a sample that uses OMMs to render the leaves of a tree.

This sample has a sibling D3D12RaytracingOMMOfflineBaker to generate OMMs for the leaves of a tree using NVIDIA’s OMM baker tool from their OMM SDK. D3D12RaytracingOpacityMicromaps renders the tree with OMMs, along with various options to toggle parameters such as the OMM subdivision level and whether or not AnyHit shaders are invoked.

D3D12RaytracingOpacityMicromaps and D3D12RaytracingOMMOfflineBaker can be found in the DirectX-Graphics-Samples repo on github here.

Here is some code from the sample showing OMM data being loaded from disk. It will subsequently be passed into OMM build.

void D3D12RaytracingOpacityMicromaps::LoadOMM(const char* ommPath, OMMSet& buffers)
{
    auto device = m_deviceResources->GetD3DDevice();

    HANDLE fhOMM = 
        CreateFileA(ommPath, GENERIC_READ, FILE_SHARE_READ, NULL, 
                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if (fhOMM == INVALID_HANDLE_VALUE)
    {
        return;
    }

    DWORD bytesRead;

    UINT ommCounts[5];
    ReadFile(fhOMM, ommCounts, sizeof(ommCounts), &bytesRead, NULL);

    UINT arrayDataSize = ommCounts[0];
    UINT descArrayCount = ommCounts[1];
    buffers.numHistogramEntries = ommCounts[2];
    UINT indexFormat = ommCounts[3];
    UINT indexCount = ommCounts[4];

    size_t descArraySize = descArrayCount * sizeof(D3D12_RAYTRACING_OPACITY_MICROMAP_DESC);
    size_t ommIndexBufferSize = indexCount * (indexFormat == 0 ? 2 : 4);

    AllocateUploadableBuffer(device, nullptr, descArraySize,
        &buffers.descBuffer.uploadResource, 
        &buffers.descBuffer.defaultResource, L"OMM Desc Buffer");
    AllocateUploadableBuffer(device, nullptr, arrayDataSize,
        &buffers.arrayBuffer.uploadResource, 
        &buffers.arrayBuffer.defaultResource, L"OMM Array Buffer");
    AllocateUploadableBuffer(device, nullptr, ommIndexBufferSize,
        &buffers.indexBuffer.uploadResource, 
        &buffers.indexBuffer.defaultResource, L"OMM Index Buffer");

    D3D12_RAYTRACING_OPACITY_MICROMAP_DESC* descArrayPtr;
    void* ommArrayPtr;
    UINT* ommIndexBufferPtr;
    buffers.descBuffer.uploadResource->Map(0, nullptr, (void**)&descArrayPtr);
    buffers.arrayBuffer.uploadResource->Map(0, nullptr, &ommArrayPtr);
    buffers.indexBuffer.uploadResource->Map(0, nullptr, (void**)&ommIndexBufferPtr);

    size_t histogramSize = 
        buffers.numHistogramEntries * sizeof(D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY);
    buffers.histogramBuffer = 
        new D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY[buffers.numHistogramEntries];

    ReadFile(fhOMM, descArrayPtr, (DWORD)descArraySize, &bytesRead, NULL);
    ReadFile(fhOMM, ommArrayPtr, (DWORD)arrayDataSize, &bytesRead, NULL);
    ReadFile(fhOMM, buffers.histogramBuffer, (DWORD)histogramSize, &bytesRead, NULL);
    ReadFile(fhOMM, ommIndexBufferPtr, (DWORD)ommIndexBufferSize, &bytesRead, NULL);

    CloseHandle(fhOMM);
}

Here is code for:

• Building device OMM objects from the device-agnostic OMM data loaded above
• Building a Bottom Level Acceleration Structure, where the geometry for the tree leaves links to the OMMs from the previous step.
• Building a Top Level Acceleration Structure to instance the tree into the scene.

void D3D12RaytracingOpacityMicromaps::BuildAccelerationStructures(bool updateUploadBuffers)
{
    auto device = m_deviceResources->GetD3DDevice();
    auto commandList = m_deviceResources->GetCommandList();

    // [Snipped code related to copying upload buffers and issuing resource barriers]

    UINT vertexCount = (UINT)m_positionBuffer.defaultResource->GetDesc().Width / sizeof(XMFLOAT3);

    // Allocate the AS build input structures on the stack
    auto linkageDescs = (D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC*)alloca(m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC));
    auto geomDescs = (D3D12_RAYTRACING_GEOMETRY_DESC*)alloca(m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_DESC));
    auto triDescs = (D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC*)alloca(m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC));

    ZeroMemory(linkageDescs, m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC));
    ZeroMemory(geomDescs, m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_DESC));
    ZeroMemory(triDescs, m_numGeoms * sizeof(D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC));

    UINT indexOffset = 0;
    UINT ommOffset = 0;

    OMMSet& ommSet = m_ommSets[m_currentSubDLevel][m_use4State ? 1 : 0];

    // For each geometry, fill out the appropriate parts of D3D12_RAYTRACING_GEOMETRY_DESC
    for (UINT i = 0; i < m_numGeoms; i++)
    {
        D3D12_RAYTRACING_GEOMETRY_DESC& geomDesc = geomDescs[i];
        D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC* triDesc;

        geomDesc.Flags = D3D12_RAYTRACING_GEOMETRY_FLAG_NONE;

        bool isAlphaTestedGeometry = (i == 2);   // In this model, the leaves are always at geometry index 2

        // OMM geometries use the new D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC
        // whereas non-OMM geometry uses the standard D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC 
        if (isAlphaTestedGeometry)
        {
            geomDesc.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES;
            geomDesc.OmmTriangles.pTriangles = &triDescs[i];
            geomDesc.OmmTriangles.pOmmLinkage = &linkageDescs[i];

            D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC& linkageDesc = linkageDescs[i];

            linkageDesc.OpacityMicromapIndexBuffer = { ommSet.indexBuffer.defaultResource‑>GetGPUVirtualAddress() + (ommOffset * sizeof(UINT)), sizeof(UINT)};
            linkageDesc.OpacityMicromapIndexFormat = DXGI_FORMAT_R32_UINT;
            linkageDesc.OpacityMicromapBaseLocation = 0;

            triDesc = &triDescs[i];
            ommOffset += (m_indicesPerGeom[i] / 3);
        }
        else
        {
            geomDesc.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
            triDesc = &geomDesc.Triangles;
        }

        geomDesc.Flags = isAlphaTestedGeometry ? D3D12_RAYTRACING_GEOMETRY_FLAG_NONE : D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;
              
        // OMM and Non-OMM Geometry Descs have a common structure which needs to be filled out regardless.
        triDesc->Transform3x4 = 0;
        triDesc->IndexFormat = DXGI_FORMAT_R32_UINT;
        triDesc->VertexFormat = DXGI_FORMAT_R32G32B32_FLOAT;
        triDesc->IndexCount = m_indicesPerGeom[i];
        triDesc->VertexCount = vertexCount;
        triDesc->IndexBuffer = m_positionIndexBuffer.defaultResource->GetGPUVirtualAddress() + indexOffset * sizeof(UINT);
        triDesc->VertexBuffer.StartAddress = m_positionBuffer.defaultResource->GetGPUVirtualAddress();
        triDesc->VertexBuffer.StrideInBytes = sizeof(XMFLOAT3);

        indexOffset += m_indicesPerGeom[i];
    }

    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS buildFlags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE;

    // Setup the OMM Array Desc
    D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC ommArrayDesc = {};
    ommArrayDesc.InputBuffer = ommSet.arrayBuffer.defaultResource->GetGPUVirtualAddress();
    ommArrayDesc.NumOmmHistogramEntries = ommSet.numHistogramEntries;
    ommArrayDesc.pOmmHistogram = (D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY*)ommSet.histogramBuffer;
    ommArrayDesc.PerOmmDescs = { ommSet.descBuffer.defaultResource->GetGPUVirtualAddress(), sizeof(D3D12_RAYTRACING_OPACITY_MICROMAP_DESC) };

    // Setup the OMM Build Desc
    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC ommBuildDesc = {};
    ommBuildDesc.Inputs.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_ARRAY;
    ommBuildDesc.Inputs.Flags = buildFlags;
    ommBuildDesc.Inputs.NumDescs = 1;
    ommBuildDesc.Inputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
    ommBuildDesc.Inputs.pOpacityMicromapArrayDesc = &ommArrayDesc;

    // Setup the Bottom Level Acceleration Structure (BLAS) Desc
    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC blasBuildDesc = {};
    blasBuildDesc.Inputs.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
    blasBuildDesc.Inputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
    blasBuildDesc.Inputs.Flags = buildFlags;
    blasBuildDesc.Inputs.NumDescs = m_numGeoms;
    blasBuildDesc.Inputs.pGeometryDescs = geomDescs;

    // Setup the Top Level Acceleration Structure Desc (TLAS) Desc
    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC tlasBuildDesc = {};
    tlasBuildDesc.Inputs.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
    tlasBuildDesc.Inputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
    tlasBuildDesc.Inputs.Flags = buildFlags;
    tlasBuildDesc.Inputs.NumDescs = 1;

    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO ommPrebuildInfo = {};
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO blasPrebuildInfo = {};
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO tlasPrebuildInfo = {};

    // Query how much Scratch and Result space is needed for each of the three acceleration structures (OMM, BLAS, TLAS)
    m_dxrDevice->GetRaytracingAccelerationStructurePrebuildInfo(&ommBuildDesc.Inputs, &ommPrebuildInfo);
    m_dxrDevice->GetRaytracingAccelerationStructurePrebuildInfo(&blasBuildDesc.Inputs, &blasPrebuildInfo);
    m_dxrDevice->GetRaytracingAccelerationStructurePrebuildInfo(&tlasBuildDesc.Inputs, &tlasPrebuildInfo);

    // [Code to allocate D3D12 resources for Scratch, OMM, BLAS and TLAS snipped for brevity]
    // [Code to allocate and update Instance Descs snipped for brevity]

    for (UINT i = 0; i < m_numGeoms; i++)
    {
        linkageDescs[i].OpacityMicromapArray = m_ommAccelerationStructure->GetGPUVirtualAddress();
    }

    // Point the OMM, BLAS and TLAS Build Descs to their respective Scratch and Result resources
    ommBuildDesc.ScratchAccelerationStructureData = m_scratchResource->GetGPUVirtualAddress();
    ommBuildDesc.DestAccelerationStructureData = m_ommAccelerationStructure->GetGPUVirtualAddress();

    blasBuildDesc.ScratchAccelerationStructureData = m_scratchResource->GetGPUVirtualAddress();
    blasBuildDesc.DestAccelerationStructureData = m_bottomLevelAccelerationStructure->GetGPUVirtualAddress();

    tlasBuildDesc.ScratchAccelerationStructureData = m_scratchResource->GetGPUVirtualAddress();
    tlasBuildDesc.DestAccelerationStructureData = m_topLevelAccelerationStructure->GetGPUVirtualAddress();
    tlasBuildDesc.Inputs.InstanceDescs = m_instanceDescs->GetGPUVirtualAddress();

    D3D12_RESOURCE_BARRIER uavBarrier = CD3DX12_RESOURCE_BARRIER::UAV(nullptr);
    
    // Build the OMM first
    m_dxrCommandList->BuildRaytracingAccelerationStructure(&ommBuildDesc, 0, nullptr);
    commandList->ResourceBarrier(1, &uavBarrier);
    
    // Followed by the BLAS, which references the OMM
    m_dxrCommandList->BuildRaytracingAccelerationStructure(&blasBuildDesc, 0, nullptr);
    commandList->ResourceBarrier(1, &uavBarrier);

    // Followed by the TLAS, which references the BLAS
    m_dxrCommandList->BuildRaytracingAccelerationStructure(&tlasBuildDesc, 0, nullptr);
    commandList->ResourceBarrier(1, &uavBarrier);
}